﻿using LiteVectorIndex.Engine;
using System.Collections.Concurrent;
using System.Security.Policy;

namespace LiteVectorIndex
{
    /// <summary>
    /// 集合操作的管理器，负责向量集合的创建、删除和查询等操作。
    /// </summary>
    public class CollectionManager
    {
        private static readonly CollectionManager _instance = new();

        private readonly ConcurrentDictionary<string, LiteVectorCollection> _collections = new();

        /// <summary>
        ///  获取集合管理器的单例实例。
        /// </summary>
        public static CollectionManager Instance
        {
            get
            {
                return _instance;
            }
        }

        private CollectionManager()
        {
            // 单件
        }

        /// <summary>
        /// 添加一个新的向量集合，如果Key已经存在，那就不在添加，而是返回已存在的集合。
        /// </summary>
        /// <param name="metricType">向量距离的算法</param>
        /// <param name="key">集合的唯一标识</param>
        /// <returns></returns>
        /// <exception cref="NotSupportedException">不支持的类型</exception>
        public LiteVectorCollection CreateNewCollection(string key, MetricType metricType, bool shouldOverride)
        {
            if (_collections.ContainsKey(key))
            {
                if (!shouldOverride)
                {
                    // 直接返回已存在的集合
                    return _collections[key];
                }
                else
                {

                    // 先删除已存在的集合
                    RemoveCollection(key);
                }
            }

            LiteVectorCollection collection = new(metricType);

            _collections[key] = collection;

            return collection;
        }

        /// <summary>
        /// 使用数据包加载一个的向量集合，如果Key已经存在，那就直接加载数据到已存在的集合中。
        /// </summary>
        /// <param name="key">集合的唯一标识</param>
        /// <param name="data">集合的配置和数据</param>
        /// <returns></returns>
        public LiteVectorCollection LoadCollection(string key, PlainCollectionData data)
        {
            if (_collections.ContainsKey(key))
            {
                var pkg = _collections[key];

                // 执行加载数据和配置更新
                pkg.LoadData(data);
                return pkg;
            }
            else
            {
                // 创建一个新的集合
                var collection = new LiteVectorCollection(data.MetricTypeInUse);
                collection.LoadData(data);

                // 加入字典   
                _collections[key] = collection;
                return collection;
            }
        }

        /// <summary>
        /// 删除一个向量集合，不存在的话就不做任何操作。
        /// </summary>
        /// <param name="key">向量集合的ID</param>
        public void RemoveCollection(string key)
        {
            // 先从字典中移除
            _collections.Remove(key, out var pkg);

            // 再清理集合中的数据
            pkg?.Clear();
        }

        /// <summary>
        /// 获取向量集合，如果不存在则抛出异常。
        /// </summary>
        /// <param name="key">向量集合的ID</param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException">指定的集合不存在</exception>
        public LiteVectorCollection GetCollection(string key)
        {
            if (_collections.ContainsKey(key))
            {
                return _collections[key];
            }
            else
            {
                throw new InvalidOperationException($"没有找到名为 '{key}' 的集合。");

            }
        }

        /// <summary>
        /// 检查集合是否已经被加载
        /// </summary>
        /// <param name="key">向量的唯一标识</param>
        /// <returns></returns>
        public bool CollectionExists(string key)
        {
            return _collections.ContainsKey(key);
        }

        public int Count()
        {

            return _collections.Count;
        }


    }


}
